home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / util / gnu / gnu_smalltalk1_2.lha / mstsave.c < prev    next >
C/C++ Source or Header  |  1992-02-15  |  22KB  |  907 lines
  1. /***********************************************************************
  2.  *
  3.  *    Binary image save/restore.
  4.  *
  5.  ***********************************************************************/
  6.  
  7. /***********************************************************************
  8.  *
  9.  * Copyright (C) 1990, 1991, 1992 Free Software Foundation, Inc.
  10.  * Written by Steve Byrne.
  11.  *
  12.  * This file is part of GNU Smalltalk.
  13.  *
  14.  * GNU Smalltalk is free software; you can redistribute it and/or modify it
  15.  * under the terms of the GNU General Public License as published by the Free
  16.  * Software Foundation; either version 1, or (at your option) any later 
  17.  * version.
  18.  * 
  19.  * GNU Smalltalk is distributed in the hope that it will be useful, but WITHOUT
  20.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  21.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  22.  * more details.
  23.  * 
  24.  * You should have received a copy of the GNU General Public License along with
  25.  * GNU Smalltalk; see the file COPYING.  If not, write to the Free Software
  26.  * Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  
  27.  *
  28.  ***********************************************************************/
  29.  
  30.  
  31. /*
  32.  *    Change Log
  33.  * ============================================================================
  34.  * Author      Date       Change 
  35.  * sbb         14 Sep 91      Added support for edit version.
  36.  *
  37.  * sbyrne    17 Apr 90      Fixing binary save to save only to the maximum used
  38.  *              OOP slot, instead of saving the entire OOP table.
  39.  *              This should improve load time and decrease disk
  40.  *              storage requirements.
  41.  *
  42.  * sbyrne    11 Feb 90      Changed the header to record the size of the oop
  43.  *              table, since trying to load back into a system with a
  44.  *              different sized oop table loses bigtime.
  45.  *
  46.  * sbyrne     5 Apr 89      modified to reflect change in classes: now their name
  47.  *              is a Smalltalk string; before, it was a C string that
  48.  *              had to be saved specially.
  49.  *
  50.  * sbyrne     4 Mar 89      Created.
  51.  *
  52.  */
  53.  
  54.  
  55. #include <stdio.h>
  56. #include "mst.h"
  57. #include "mstsave.h"
  58. #include "mstcomp.h"
  59. #include "mstinterp.h"
  60. #include "mstdict.h"
  61. #include "mstsym.h"
  62. #include "mstoop.h"        /* indirectly defines oopAt for sym tab prof */
  63. #include "mstlib.h"
  64. #ifdef HAS_ALLOCA_H
  65. #include <alloca.h>
  66. #endif
  67. #include <stdio.h>
  68.  
  69. #ifndef MAXPATHLEN
  70. #define MAXPATHLEN        1024 /* max length of a file and path */
  71. #endif
  72.  
  73. #define fromBeginning        0 /* symbolic name for file offset modifier */
  74.  
  75. /* convert to a relative offset from start of OOP table */
  76. #define toRelative(obj) \
  77.   ( (OOP)((long)(obj) - (long)oopTable) )
  78.  
  79. /* convert from relative offset to actual oop table address */
  80. #define fromRelative(obj) \
  81.   ( (OOP)((long)(obj) + (long)oopTable) )
  82.  
  83. /* round "x" up to the next 4 byte boundary */
  84. #define roundUpWord(x) \
  85.   ( ((x) + 3) & ~3 )
  86.  
  87. /*
  88.  * The binary image file has the following format:
  89.  *
  90.  *    header
  91.  *    complete oop table
  92.  *    global oop variable data
  93.  *    objects and non-oop object data
  94.  *    char object data
  95.  *    nil object
  96.  *    boolean objects
  97.  */
  98.  
  99.  
  100. typedef struct SaveFileHeaderStruct {
  101.   long        version;    /* the Smalltalk version that made this dump */
  102.   unsigned long    objectDataSize;    /* size of object data section in bytes */
  103.   unsigned long    oopTableSize;    /* size of the oop table at dump */
  104.   unsigned long    semiSpaceSize;    /* size of the semi spaces at dump time */
  105. } SaveFileHeader;
  106.  
  107. typedef struct OOPVectorStruct {
  108.   Object    base;        /* base of the storage */
  109.   Object    ptr;        /* the current object */
  110. } OOPVector;
  111.  
  112.  
  113. OOP        *globalOOPs[] = {
  114.   &andColonSymbol,
  115.   &atColonPutColonSymbol,
  116.   &atColonSymbol,
  117.   &atEndSymbol,
  118.   &bitAndColonSymbol,
  119.   &bitOrColonSymbol,
  120.   &bitShiftColonSymbol,
  121.   &blockCopyColonSymbol,
  122.   &classSymbol,
  123.   ÷Symbol,
  124.   &doColonSymbol,
  125.   &equalSymbol,
  126.   &greaterEqualSymbol,
  127.   &greaterThanSymbol,
  128.   &ifFalseColonIfTrueColonSymbol,
  129.   &ifFalseColonSymbol,
  130.   &ifTrueColonIfFalseColonSymbol,
  131.   &ifTrueColonSymbol,
  132.   &integerDivideSymbol,
  133.   &lessEqualSymbol,
  134.   &lessThanSymbol,
  135.   &minusSymbol,
  136.   &newColonSymbol,
  137.   &newSymbol,
  138.   &nextPutColonSymbol,
  139.   &nextSymbol,
  140.   ¬EqualSymbol,
  141.   ¬SameObjectSymbol,
  142.   &orColonSymbol,
  143.   &plusSymbol,
  144.   &remainderSymbol,
  145.   &sameObjectSymbol,
  146.   &sizeSymbol,
  147.   &thisContextSymbol,
  148.   ×Symbol,
  149.   &valueColonSymbol,
  150.   &valueColonValueColonSymbol,
  151.   &valueColonValueColonValueColonSymbol,
  152.   &valueWithArgumentsColonSymbol,
  153.   &valueSymbol,
  154.   &whileFalseColonSymbol,
  155.   &whileTrueColonSymbol,
  156.   &orSymbol,
  157.   &andSymbol,
  158.   &superSymbol,
  159.   &nilSymbol,
  160.   &trueSymbol,
  161.   &falseSymbol,
  162.   &selfSymbol,
  163.   &doesNotUnderstandColonSymbol,
  164.   &unknownSymbol,
  165.   &charSymbol,
  166.   &stringSymbol,
  167.   &stringOutSymbol, 
  168.   &symbolSymbol,
  169.   &intSymbol,
  170.   &longSymbol,
  171.   &doubleSymbol,
  172.   &voidSymbol,
  173.   &variadicSymbol,
  174.   &cObjectSymbol,
  175.   &smalltalkSymbol,
  176.   &byteArraySymbol,
  177.   &byteArrayOutSymbol,
  178.   &objectClass,
  179.   &magnitudeClass,
  180.   &charClass,
  181.   &timeClass,
  182.   &numberClass,
  183.   &floatClass,
  184.   &integerClass,
  185.   &lookupKeyClass,
  186.   &associationClass,
  187.   &linkClass,
  188.   &processClass,
  189.   &symLinkClass,
  190.   &collectionClass,
  191.   &sequenceableCollectionClass,
  192.   &linkedListClass,
  193.   &semaphoreClass,
  194.   &arrayedCollectionClass,
  195.   &arrayClass,
  196.   &stringClass,
  197.   &symbolClass,
  198.   &byteArrayClass,
  199.   &compiledMethodClass,
  200.   &intervalClass,
  201.   &orderedCollectionClass,
  202.   &sortedCollectionClass,
  203.   &bagClass,
  204.   &mappedCollectionClass,
  205.   &setClass,
  206.   &dictionaryClass,
  207.   &identityDictionaryClass,
  208.   &systemDictionaryClass,
  209.   &undefinedObjectClass,
  210.   &booleanClass,
  211.   &falseClass,
  212.   &trueClass,
  213.   &processorSchedulerClass,
  214.   &delayClass,
  215.   &sharedQueueClass,
  216.   &behaviorClass,
  217.   &classDescriptionClass,
  218.   &classClass,
  219.   &metaclassClass,
  220.   &smalltalkDictionary,
  221.   &messageClass,
  222.   &methodContextClass,
  223.   &blockContextClass,
  224.   &streamClass,
  225.   &positionableStreamClass,
  226.   &readStreamClass,
  227.   &writeStreamClass,
  228.   &readWriteStreamClass,
  229.   &cObjectClass,
  230.   &cTypeClass,
  231.   &fileStreamClass,
  232.   &memoryClass,
  233.   &byteMemoryClass,
  234.   &wordMemoryClass,
  235.   &randomClass,
  236.   &cFuncDescriptorClass,
  237.   &tokenStreamClass,
  238.   &methodInfoClass,
  239.   &fileSegmentClass,
  240.   &nilOOP,
  241.   &trueOOP,
  242.   &falseOOP,
  243.   &processorOOP,
  244.   &symbolTable,
  245.   nil
  246. };
  247.  
  248.  
  249. static void    skipOverHeader(), saveObject(), fixupObject(),
  250.         fixupMethodObject(), restoreObject(), restoreMethodObject(),
  251.         saveOOPTable(), fixupAllOOPs(), fixupOOP(),
  252.         /* fixupFreeOOP(), */restoreAllOOPs(), restoreOOP(), 
  253.         /*restoreFreeOOP(), */loadOOPTable(), loadNormalOOPs(),
  254.         loadCharOOPs(), loadSpecialOOPs(), saveGlobalOOPs(),
  255.         loadGlobalOOPs(), fixupClassObject(), restoreInstanceVars(),
  256.         restoreClassObject(), saveFileVersion(),
  257.         loadFileVersion(), fixupInstanceVars(), fixupOOPInstanceVars();
  258.  
  259. static int    saveNormalOOPs(), saveAllObjects();
  260.  
  261.  
  262. /* This variable contains the OOP slot index of the highest non-free OOP,
  263.  * excluding the built-in ones (i.e., it will always be < OOP_TABLE_SIZE).
  264.  * This is used for optimizing the size of the saved image, and minimizing
  265.  * the load time when restoring the system. */
  266. static int    maxUsedOOPSlot = 0;
  267.  
  268.  
  269. Boolean saveToFile(fileName)
  270. char    *fileName;
  271. {
  272.   FILE        *imageFile;
  273.   unsigned long    objectDataSize;
  274.   Boolean    oldGCState;
  275.  
  276.   realizeMethodContexts();    /* make sure all contexts are real */
  277.  
  278. #ifdef pre_sc_gc /* Sat Jul 27 22:33:36 1991 */
  279. /**/  fullGC();            /* make sure that the world is compact if
  280. /**/                   possible */
  281. /**/
  282. #endif /* pre_sc_gc Sat Jul 27 22:33:36 1991 */
  283.   gcFlip();            /* make sure that the world is compact if
  284.                  * possible */
  285.   oldGCState = gcOff();
  286.  
  287. #ifdef BINARY_MODE_NEEDED
  288.   imageFile = fopen(fileName, "wb");
  289. #else
  290.   imageFile = fopen(fileName, "w");
  291. #endif
  292.   if (imageFile == NULL) {
  293.     errorf("Couldn't open file %s", fileName);
  294.     return (false);
  295.   }
  296.  
  297.   skipOverHeader(imageFile);
  298.   saveOOPTable(imageFile);
  299.  
  300. #ifdef OOP_TABLE_TRACE
  301. printf("After saving oopt table: %d\n", ftell(imageFile));
  302. #endif /* OOP_TABLE_TRACE */
  303.  
  304.   saveGlobalOOPs(imageFile);
  305.  
  306. #ifdef OOP_TABLE_TRACE
  307. printf("After global oop table: %d\n", ftell(imageFile));
  308. #endif /* OOP_TABLE_TRACE */
  309.  
  310.   objectDataSize = saveAllObjects(imageFile);
  311.  
  312. #ifdef OOP_TABLE_TRACE
  313. printf("After saving all objects table: %d\n", ftell(imageFile));
  314. #endif /* OOP_TABLE_TRACE */
  315.  
  316.   skipToHeader(imageFile);
  317.   saveFileVersion(imageFile, objectDataSize);
  318.  
  319.   fclose(imageFile);
  320.  
  321.   setGCState(oldGCState);
  322.   return (true);
  323. } 
  324.  
  325.  
  326. static void skipOverHeader(imageFile)
  327. FILE    *imageFile;
  328. {
  329.   fseek(imageFile, sizeof(SaveFileHeader), fromBeginning);
  330. }
  331.  
  332. /*
  333.  *    static void saveOOPTable(imageFile)
  334.  *
  335.  * Description
  336.  *
  337.  *    Writes the OOP table out to the image file.  We need to make all
  338.  *    of the object pointers relative, including free OOP table slots, and
  339.  *    we use a parallel vector containing file offsets for the objects that
  340.  *    we developed during saving of the objects themselves as the fixup
  341.  *    table.
  342.  *
  343.  * Inputs
  344.  *
  345.  *    imageFile: 
  346.  *        A stdio FILE to be written to.  It must be positioned
  347.  *        correctly before this routine is called.
  348.  *
  349.  */
  350. static void saveOOPTable(imageFile)
  351. FILE    *imageFile;
  352. {
  353.   fixupAllOOPs();
  354.  
  355. #ifdef OOP_TABLE_TRACE
  356. printf("there are %d free oops out of %d oops, leaving %d\n",
  357.        numFreeOOPs, OOP_TABLE_SIZE, OOP_TABLE_SIZE - numFreeOOPs);
  358. printf("max used is %d\n", maxUsedOOPSlot);
  359. #endif /* OOP_TABLE_TRACE */
  360.  
  361.   /* save up to the max oop slot in use */
  362.   fwrite(oopTable, sizeof(struct OOPStruct), maxUsedOOPSlot + 1, imageFile);
  363.  
  364.   /* then save the constant ones at the end */
  365.   fwrite(&oopTable[OOP_TABLE_SIZE], sizeof(struct OOPStruct),
  366.      TOTAL_OOP_TABLE_SLOTS - OOP_TABLE_SIZE, imageFile);
  367.  
  368.   restoreAllOOPs();
  369. }
  370.  
  371.  
  372. static void fixupAllOOPs()
  373. {
  374.   int        i;
  375.  
  376.   maxUsedOOPSlot = 0;
  377.  
  378.   for (i = 0; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  379.     fixupOOP(i);
  380.   }
  381. }
  382.  
  383. static void fixupOOP(i)
  384. int    i;
  385. {
  386.   OOP        oop;
  387.  
  388.   oop = oopAt(i);
  389.   if (!(oop->flags & F_FREE)) {
  390.     if (i < OOP_TABLE_SIZE) {
  391.       maxUsedOOPSlot = i;
  392.     }
  393.     oop->object = (Object)toRelative(oop->object);
  394.   }
  395. }
  396.  
  397.  
  398.  
  399. static void restoreAllOOPs()
  400. {
  401.   int        i;
  402.  
  403.   for (i = 0; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  404.     restoreOOP(i);
  405.   }
  406. }
  407.  
  408.  
  409.  
  410. static void restoreOOP(i)
  411. int    i;
  412. {
  413.   OOP        oop;
  414.  
  415.   oop = oopAt(i);
  416.   if (!(oop->flags & F_FREE)) {
  417.     oop->object = (Object)fromRelative(oop->object);
  418.   }
  419. }
  420.  
  421. #ifdef old_code /* Tue Apr 17 22:50:39 1990 */
  422. /**/static void restoreFreeOOP(oop)
  423. /**/OOP    oop;
  424. /**/{
  425. /**/  if (oop->object == (Object)-1L) {
  426. /**/    oop->object = nil;
  427. /**/  } else {
  428. /**/    oop->object = (Object)fromRelative(oop->object);
  429. /**/  }
  430. /**/
  431. /**/  if (oop->prevFree == -1L) {
  432. /**/    oop->prevFree = (long)nil;
  433. /**/  } else {
  434. /**/    oop->isFree = 0;
  435. /**/    oop->prevFree = (long)fromRelative(oop->prevFree);
  436. /**/  }
  437. /**/
  438. /**/  oop->isFree = 1;
  439. /**/}
  440. #endif /* old_code Tue Apr 17 22:50:39 1990 */
  441.  
  442.  
  443. static void saveGlobalOOPs(imageFile)
  444. FILE    *imageFile;
  445. {
  446.   OOP        **oopPtr, oop;
  447.  
  448.   for (oopPtr = globalOOPs; *oopPtr; oopPtr++) {
  449.     oop = toRelative(**oopPtr);
  450.     fwrite(&oop, sizeof(OOP), 1, imageFile);
  451.   }
  452. }
  453.  
  454.  
  455. static int saveAllObjects(imageFile)
  456. FILE    *imageFile;
  457. {
  458.   long        objectStart, objectEnd;
  459.   int        i;
  460.   OOP        oop;
  461.  
  462.   objectStart = ftell(imageFile);
  463.   for (i = 0; i < OOP_TABLE_SIZE; i++) {
  464.     oop = oopAt(i);
  465.     if (!(oop->flags & F_FREE)) {
  466. #ifdef pre_sc_gc /* Sun Jul 28 13:31:33 1991 */
  467. /**/    if (oopValid(oop)) {
  468. #endif /* pre_sc_gc Sun Jul 28 13:31:33 1991 */
  469.       saveObject(imageFile, oop);
  470.     }
  471.   }
  472.  
  473.   objectEnd = ftell(imageFile);
  474.  
  475.   /* dump out the character objects, nil, true, and false */
  476.   for (i = OOP_TABLE_SIZE; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  477.     saveObject(imageFile, oopAt(i));
  478.   }
  479.  
  480.   return (objectEnd - objectStart);
  481. }
  482.  
  483. static void saveObject(imageFile, oop)
  484. FILE    *imageFile;
  485. OOP    oop;
  486. {
  487.   Object    object;
  488.   int        numFixed, numIndexed;
  489.   Boolean    hasPointers;
  490.  
  491.   object = oopToObj(oop);
  492.   hasPointers = isPointers(oop);
  493.   numFixed = oopFixedFields(oop);
  494.   numIndexed = numIndexableFields(oop);
  495.  
  496.   fixupObject(oop, hasPointers, numFixed, numIndexed);
  497.   fwrite(object, sizeof(OOP), object->objSize, imageFile);
  498.   restoreObject(oop, hasPointers, numFixed, numIndexed);
  499. }
  500.  
  501. static void fixupObject(oop, hasPointers, numFixed, numIndexed)
  502. OOP    oop;
  503. Boolean    hasPointers;
  504. int    numFixed, numIndexed;
  505. {
  506.   int        i;
  507.   Object    object;
  508.   OOP        instOOP, classOOP;
  509.  
  510.   classOOP = oopClass(oop);
  511.  
  512.   if (classOOP == compiledMethodClass) {
  513.     fixupMethodObject(oop);
  514.   } else {
  515.     if (hasPointers) {
  516.       for (i = 1; i <= numFixed + numIndexed; i++) {
  517.     instOOP = instVarAt(oop, i);
  518.     if (!isInt(instOOP)) {
  519.       instVarAtPut(oop, i, toRelative(instOOP));
  520.     }
  521.       }
  522.     }
  523.   }
  524.  
  525.   object = oopToObj(oop);
  526.   object->objClass = toRelative(object->objClass);
  527. }
  528.  
  529. static void fixupMethodObject(oop)
  530. OOP    oop;
  531. {
  532.   MethodHeader    header;
  533.   int        i;
  534.   OOP        literalOOP, descriptorOOP;
  535.  
  536.   descriptorOOP = getMethodDescriptor(oop);
  537.   if (!isInt(descriptorOOP)) {
  538.     setMethodDescriptor(oop, toRelative(descriptorOOP));
  539.   }
  540.   header = getMethodHeaderExt(oop);
  541.   if (header.headerFlag == 1 || header.headerFlag == 2) {
  542.     /* these have no method literals to fix up, so we ignore them */
  543.     return;
  544.   }
  545.  
  546.   for (i = 0; i < header.numLiterals; i++) {
  547.     literalOOP = methodLiteralExt(oop, i);
  548.     if (!isInt(literalOOP)) {
  549.       storeMethodLiteralNoGC(oop, i, toRelative(literalOOP));
  550.     }
  551.   }
  552. }
  553.  
  554. static void restoreObject(oop, hasPointers, numFixed, numIndexed)
  555. OOP    oop;
  556. Boolean    hasPointers;
  557. int    numFixed, numIndexed;
  558. {
  559.   Object    object;
  560.  
  561.   object = oopToObj(oop);
  562.  
  563.   object->objClass = fromRelative(object->objClass);
  564.  
  565.   restoreInstanceVars(oop, hasPointers, numFixed, numIndexed);
  566. }
  567.  
  568. static void restoreInstanceVars(oop, hasPointers, numFixed, numIndexed)
  569. OOP    oop;
  570. Boolean    hasPointers;
  571. int    numFixed, numIndexed;
  572. {
  573.   register int    i;
  574.   OOP        instOOP, classOOP;
  575.  
  576.   classOOP = oopClass(oop);
  577.   if (classOOP == compiledMethodClass) {
  578.     restoreMethodObject(oop);
  579.   } else {
  580.     if (hasPointers) {
  581.       for (i = 1; i <= numFixed + numIndexed; i++) {
  582.     instOOP = instVarAt(oop, i);
  583.     if (!isInt(instOOP)) {
  584.       instVarAtPut(oop, i, fromRelative(instOOP));
  585.     }
  586.       }
  587.       if (classOOP == cFuncDescriptorClass) {
  588.     restoreCFuncDescriptor(oop); /* in mstcint.c */
  589.       }
  590.     }
  591.   }
  592. }
  593.  
  594. static void restoreMethodObject(oop)
  595. OOP    oop;
  596. {
  597.   MethodHeader    header;
  598.   int        i;
  599.   OOP        literalOOP, descriptorOOP;
  600.  
  601.   descriptorOOP = getMethodDescriptor(oop);
  602.   if (!isInt(descriptorOOP)) {
  603.     setMethodDescriptor(oop, fromRelative(descriptorOOP));
  604.   }
  605.  
  606.   header = getMethodHeaderExt(oop);
  607.   if (header.headerFlag == 1 || header.headerFlag == 2) {
  608.     /* these have no method literals to fix up, so we ignore them */
  609.     return;
  610.   }
  611.  
  612.   for (i = 0; i < header.numLiterals; i++) {
  613.     literalOOP = methodLiteralExt(oop, i);
  614.     if (!isInt(literalOOP)) {
  615.       storeMethodLiteralNoGC(oop, i, fromRelative(literalOOP));
  616.     }
  617.   }
  618. }
  619.  
  620.  
  621. skipToHeader(imageFile)
  622. FILE    *imageFile;
  623. {
  624.   rewind(imageFile);
  625. }
  626.  
  627. static void saveFileVersion(imageFile, objectDataSize)
  628. FILE    *imageFile;
  629. unsigned long objectDataSize;
  630. {
  631.   SaveFileHeader header;
  632.  
  633.   header.version = sysVersMajor * 1000000 + sysVersMinor * 1000 + sysVersEdit;
  634.   header.objectDataSize = objectDataSize;
  635.   header.oopTableSize = maxUsedOOPSlot + 1; /* n slots, numbered 0..n-1 */
  636.   header.semiSpaceSize = maxSpaceSize;
  637.  
  638.   fwrite(&header, sizeof(SaveFileHeader), 1, imageFile);
  639. }
  640.  
  641. static void skipToOOPTable(imageFile)
  642. FILE    *imageFile;
  643. {
  644.   rewind(imageFile);
  645. }
  646.  
  647.  
  648. /***********************************************************************
  649.  *
  650.  *    Binary loading routines.
  651.  *
  652.  ***********************************************************************/
  653.  
  654.  
  655. Boolean loadFromFile(fileName)
  656. char    *fileName;
  657. {
  658.   FILE        *imageFile;
  659.   SaveFileHeader header;
  660.   OOPVector    ov;
  661.   Boolean    oldGCState;
  662.   char        fullImageName[MAXPATHLEN];
  663.  
  664.   oldGCState = gcOff();
  665.  
  666.   findImageFile(fileName, fullImageName);
  667. #ifdef BINARY_MODE_NEEDED
  668.   imageFile = fopen(fullImageName, "rb");
  669. #else
  670.   imageFile = fopen(fullImageName, "r");
  671. #endif
  672.   if (imageFile == NULL) {
  673.     fclose(imageFile);
  674.     setGCState(oldGCState);
  675.     return (false);
  676.   }
  677.  
  678.   loadFileVersion(imageFile, &header);
  679.   if (header.version != (sysVersMajor * 1000000 + sysVersMinor * 1000
  680.              + sysVersEdit)) {
  681.     /* version mismatch; this image file is invalid */
  682.     fclose(imageFile);
  683.     setGCState(oldGCState);
  684.     return (false);
  685.   }
  686.   
  687.   if (header.semiSpaceSize != maxSpaceSize) {
  688.     growBothSpaces(header.semiSpaceSize);
  689.   }
  690.  
  691. #ifdef old_code /* Tue Apr 17 22:25:33 1990 */
  692. /**/  if (header.oopTableSize != OOP_TABLE_SIZE) {
  693. /**/    return (false);
  694. /**/  }
  695. #endif /* old_code Tue Apr 17 22:25:33 1990 */
  696.  
  697.   allocOOPTable();
  698.   loadOOPTable(imageFile, header.oopTableSize);
  699.  
  700.   loadGlobalOOPs(imageFile);
  701.  
  702.   loadNormalOOPs(imageFile, header.objectDataSize, &ov);
  703.   loadCharOOPs(imageFile);
  704.   loadSpecialOOPs(imageFile);
  705.  
  706.   fixupInstanceVars(&ov);
  707.  
  708.   fclose(imageFile);
  709.  
  710.   setGCState(oldGCState);
  711.  
  712. dictInit();            /* ### TEMP HACK ### */
  713.  
  714.   return (true);
  715. }
  716.  
  717. static void loadFileVersion(imageFile, headerp)
  718. FILE    *imageFile;
  719. SaveFileHeader *headerp;
  720. {
  721.   fread(headerp, sizeof(SaveFileHeader), 1, imageFile);
  722. }
  723.  
  724. static void loadOOPTable(imageFile, oldSlotsUsed)
  725. FILE    *imageFile;
  726. long     oldSlotsUsed;
  727. {
  728.   long        i;
  729.   OOP        oop;
  730.  
  731. /*  fread(oopTable, sizeof(struct OOPStruct), TOTAL_OOP_TABLE_SLOTS, imageFile);*/
  732.  
  733.   /* load in the valid OOP slots from previous dump */
  734.   fread(oopTable, sizeof(struct OOPStruct), oldSlotsUsed, imageFile);
  735.   
  736.   /* mark the remaining ones as available */
  737.   for (i = oldSlotsUsed; i < OOP_TABLE_SIZE; i++) {
  738.     oop = oopAt(i);
  739.     oop->flags = F_FREE;
  740.   }
  741.  
  742.  
  743.   /* read in the constant stuff at the end */
  744.   fread(&oopTable[OOP_TABLE_SIZE], sizeof(struct OOPStruct),
  745.     TOTAL_OOP_TABLE_SLOTS - OOP_TABLE_SIZE, imageFile);
  746.  
  747.   /* the fixup gets handled by load normal oops */
  748. }
  749.  
  750.  
  751. static void loadGlobalOOPs(imageFile)
  752. FILE    *imageFile;
  753. {
  754.   OOP        **oopPtr, oop, *oopVec;
  755.   long        numGlobalOOPs;
  756.  
  757.   for (numGlobalOOPs = 0, oopPtr = globalOOPs; *oopPtr;
  758.        oopPtr++, numGlobalOOPs++);
  759.  
  760.   oopVec = (OOP *)alloca(numGlobalOOPs * sizeof(OOP));
  761.   fread(oopVec, sizeof(OOP), numGlobalOOPs, imageFile);
  762.  
  763.   for (oopPtr = globalOOPs; *oopPtr; oopPtr++, oopVec++) {
  764.     **oopPtr = fromRelative(*oopVec);
  765.   }
  766. #ifdef old_code /* Wed Apr 26 21:15:38 1989 */ /* <<<== what dedication...3 days before my wedding -- SBB */
  767. /**/  /* ??? this could be sped up by using alloca, doing one fread, and then
  768. /**/     iterating through the array */
  769. /**/  for (oopPtr = globalOOPs; *oopPtr; oopPtr++) {
  770. /**/    fread(&oop, sizeof(OOP), 1, imageFile);
  771. /**/    **oopPtr = fromRelative(oop);
  772. /**/  }
  773. #endif /* old_code Wed Apr 26 21:15:38 1989 */
  774. }
  775.  
  776. static void loadNormalOOPs(imageFile, objectDataSize, ovp) 
  777. FILE    *imageFile;
  778. unsigned long objectDataSize;
  779. OOPVector *ovp;
  780. {
  781.   register long    i;
  782.   OOP        oop, prevFreeOOP;
  783.   Object    object, objPtr;
  784.  
  785.   objPtr = curSpaceAddr();
  786.  
  787.   ovp->base = objPtr;
  788.  
  789.   prevFreeOOP = nil;
  790.  
  791.   fread(objPtr, 1, objectDataSize, imageFile);
  792.  
  793. #ifdef pre_sc_gc /* Sat Jul 27 22:32:54 1991 */
  794. /**/  freeOOPs = nil;
  795. #endif /* pre_sc_gc Sat Jul 27 22:32:54 1991 */
  796.   numFreeOOPs = 0;
  797.   for (i = 0; i < OOP_TABLE_SIZE; i++) {
  798.     oop = oopAt(i);
  799.     if (!(oop->flags & F_FREE)) {
  800. #ifdef pre_sc_gc /* Sun Jul 28 13:34:39 1991 */
  801. /**/    if (oopValid(oop)) {
  802. #endif /* pre_sc_gc Sun Jul 28 13:34:39 1991 */
  803.       object = objPtr;
  804.       oop->object = object;
  805.       /* ### should probably make this setting symbolic/abstracted */
  806.       oop->flags &= ~(F_SPACE|F_EVEN|F_ODD);
  807.       oop->flags |= toSpace;
  808.       if (toSpace) {
  809.     oop->flags |= F_ODD;
  810.       } else {
  811.     oop->flags |= F_EVEN;
  812.       }
  813.       object->objClass = fromRelative(object->objClass);
  814.       objPtr = (Object)((long *)object + object->objSize);
  815.     } else if (oop->flags & F_FREE) {
  816.       /* ignore non-free but non-valid...they'll get handled
  817.        * naturally in due time. */
  818.       numFreeOOPs++;
  819.       oop->flags = F_FREE;    /* just free */
  820. #ifdef pre_sc_gc /* Sat Jul 27 22:00:04 1991 */
  821. /**/      if (prevFreeOOP) {    /* forward chain the oop free list */
  822. /**/    prevFreeOOP->object = (Object)oop;
  823. /**/      }
  824. /**/      if (freeOOPs == nil) {    /* free list points at first free oop in
  825. /**/                   OOP table */
  826. /**/    freeOOPs = oop;
  827. /**/      }
  828. /**/      prevFreeOOP = oop;
  829. #endif /* pre_sc_gc Sat Jul 27 22:00:04 1991 */
  830.     }
  831.   }
  832.  
  833. #ifdef pre_sc_gc /* Sat Jul 27 22:00:13 1991 */
  834. /**/  if (prevFreeOOP) {
  835. /**/    prevFreeOOP->object = nil;    /* terminate the free list nicely */
  836. /**/  }
  837. #endif /* pre_sc_gc Sat Jul 27 22:00:13 1991 */
  838.  
  839.   setSpaceInfo(objectDataSize);
  840.   ovp->ptr = objPtr;
  841. }
  842.  
  843. static void loadCharOOPs(imageFile)
  844. FILE    *imageFile;
  845. {
  846.   int        i;
  847.  
  848.   fread(charObjectTable, sizeof(CharObject), NUM_CHAR_OBJECTS, imageFile);
  849.  
  850. /* ### Inconsistency here... using direct refs to oopTable, instead of oopAts
  851.  * like above.  Probably should convert the whole thing to pointers into
  852.  * the oopTable and be done with it.
  853.  */
  854.   for (i = 0; i < NUM_CHAR_OBJECTS; i++) {
  855.     oopTable[i + CHAR_OBJECT_BASE].object = (Object)&charObjectTable[i];
  856.     oopTable[i + CHAR_OBJECT_BASE].flags &= ~F_SPACE;
  857.     oopTable[i + CHAR_OBJECT_BASE].flags |= toSpace;
  858.     charObjectTable[i].objClass = fromRelative(charObjectTable[i].objClass);
  859.   }
  860. }
  861.  
  862. static void loadSpecialOOPs(imageFile)
  863. FILE    *imageFile;
  864. {
  865.   fread(&nilObject, sizeof(struct NilObjectStruct), 1, imageFile);
  866.   nilOOP->object = (Object)&nilObject;
  867.   nilOOP->object->objClass = fromRelative(nilOOP->object->objClass);
  868. /* ### not sure that I can just assign directly into flags...seems ok, though*/
  869.   nilOOP->flags = toSpace;
  870.  
  871.   fread(booleanObjects, sizeof(struct BooleanObjectStruct), 2, imageFile);
  872.   trueOOP->object = (Object)&booleanObjects[0];
  873.   falseOOP->object = (Object)&booleanObjects[1];
  874.   trueOOP->object->objClass = fromRelative(trueOOP->object->objClass);
  875.   falseOOP->object->objClass = fromRelative(falseOOP->object->objClass);
  876.   trueOOP->flags = falseOOP->flags = toSpace;
  877. }
  878.  
  879. static void fixupInstanceVars(ovp)
  880. OOPVector *ovp;
  881. {
  882.   int        i;
  883.   OOP        oop;
  884.  
  885.   for (i = 0; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  886.     oop = oopAt(i);
  887.     if (oopValid(oop)) {
  888.       fixupOOPInstanceVars(oop, ovp);
  889.     }
  890.   }
  891. }
  892.  
  893. static void fixupOOPInstanceVars(oop, ovp)
  894. OOP    oop;
  895. OOPVector *ovp;
  896. {
  897.   int        numFixed, numIndexed;
  898.   Boolean    hasPointers;
  899.  
  900.   hasPointers = isPointers(oop);
  901.   numFixed = oopFixedFields(oop);
  902.   numIndexed = numIndexableFields(oop);
  903.   restoreInstanceVars(oop, hasPointers, numFixed, numIndexed);
  904. }
  905.  
  906.  
  907.